import java.io.*;
import java.math.BigInteger;
import java.util.*;

/**
 * @author Egor Kulikov (egor@egork.net)
 */
public class TaskJ {
	@SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
	private final InputReader in;
	private final PrintWriter out;
	private final boolean testMode;

	private static long convert(String ip) {
		String[] parts = ip.split("[.]");
		return (Long.parseLong(parts[0]) << 24) + (Long.parseLong(parts[1]) << 16) +
			(Long.parseLong(parts[2]) << 8) + Long.parseLong(parts[3]);
	}

	private static final long FULL = (1L << 32) - 1;

	private static class Segment implements Comparable<Segment> {
		private final long a, host, b;

		private Segment(String ip, String mask, String type) {
			long m = convert(mask);
			a = convert(ip) & m;
			host = convert(type);
			b = ((m - 1) ^ m) / 2 + a;
		}

		private Segment(long a, long b, long host) {
			this.a = a;
			this.b = b;
			this.host = host;
		}

		public int compareTo(Segment o) {
			if (a < o.a)
				return -1;
			if (a > o.a)
				return 1;
			if (b < o.b)
				return -1;
			if (b > o.b)
				return 1;
			return 0;
		}
	}

	private static class Table {
		private final NavigableSet<Segment> routes = new TreeSet<Segment>();

		public void addSegment(Segment segment) {
			Segment left = new Segment(segment.a, segment.a, segment.host);
			Segment right = new Segment(segment.b, segment.b, segment.host);
			long lastB = segment.a - 1;
			List<Segment> toAdd = new ArrayList<Segment>();
			for (Segment inner : routes.headSet(right, true).tailSet(left, true)) {
				if (lastB + 1 >= inner.a) {
					lastB = inner.b;
					continue;
				}
				Segment current = new Segment(lastB + 1, inner.a - 1, segment.host);
				toAdd.add(current);
				lastB = inner.b;
			}
			if (lastB < segment.b)
				toAdd.add(new Segment(lastB + 1, segment.b, segment.host));
			for (Segment part : toAdd)
				routes.add(part);
		}

		private void addImpl(Segment part) {
			Segment left = routes.floor(part);
			if (left != null && left.b == part.a - 1 && left.host == part.host) {
				routes.remove(left);
				part = new Segment(left.a, part.b, part.host);
			}
			Segment right = routes.ceiling(part);
			if (right != null && right.a == part.b + 1 && right.host == part.host) {
				routes.remove(right);
				part = new Segment(part.a, right.b, part.host);
			}
			routes.add(part);
		}

		@Override
		public boolean equals(Object o) {
			if (this == o) return true;
			if (o == null || getClass() != o.getClass()) return false;

			Table table = (Table) o;

			return !(routes != null ? !routes.equals(table.routes) : table.routes != null);

		}

		@Override
		public int hashCode() {
			return routes != null ? routes.hashCode() : 0;
		}

		public void normalize() {
			Segment last = null;
			List<Segment> normalized = new ArrayList<Segment>();
			for (Segment segment : routes) {
				if (last == null) {
					last = segment;
					continue;
				}
				if (last.b == segment.a - 1 && last.host == segment.host)
					last = new Segment(last.a, segment.b, last.host);
				else {
					normalized.add(last);
					last = segment;
				}
			}
			if (last != null)
				normalized.add(last);
			routes.clear();
			routes.addAll(normalized);
		}
	}

	private void solve() {
		Table[] tables = new Table[2];
		for (int i = 0; i < 2; i++) {
			int n = in.readInt();
			Segment[] segments = new Segment[n];
			for (int j = 0; j < n; j++) {
				String ip = in.readString();
				String mask = in.readString();
				String host = in.readString();
				segments[j] = new Segment(ip, mask, host);
			}
			Arrays.sort(segments, new Comparator<Segment>() {
				public int compare(Segment o1, Segment o2) {
					long dif1 = o1.b - o1.a;
					long dif2 = o2.b - o2.a;
					if (dif1 < dif2)
						return -1;
					if (dif1 > dif2)
						return 1;
					return 0;
				}
			});
			tables[i] = new Table();
			for (Segment segment : segments)
				tables[i].addSegment(segment);
			tables[i].normalize();
		}
		out.println(tables[0].equals(tables[1]) ? "YES" : "NO");
	}

	private static List<Test> createTests() {
		List<Test> tests = new ArrayList<Test>();
		tests.add(new Test("6\n" +
			"0.0.0.0 255.255.255.255 0.0.0.0\n" +
			"0.0.0.1 255.255.255.255 0.0.0.0\n" +
			"0.0.0.2 255.255.255.255 0.0.0.0\n" +
			"0.0.0.3 255.255.255.255 0.0.0.0\n" +
			"0.0.0.4 255.255.255.255 0.0.0.0\n" +
			"0.0.0.2 255.255.255.254 0.0.0.1\n" +
			"2\n" +
			"0.0.0.0 255.255.255.252 0.0.0.0\n" +
			"0.0.0.4 255.255.255.255 0.0.0.0", "YES"));
		tests.add(new Test("3\n" +
			"0.0.0.0 255.255.255.252 0.0.0.0\n" +
			"0.0.0.1 255.255.255.255 0.0.0.1\n" +
			"0.0.0.2 255.255.255.255 0.0.0.2\n" +
			"4\n" +
			"0.0.0.0 255.255.255.255 0.0.0.0\n" +
			"0.0.0.1 255.255.255.255 0.0.0.1\n" +
			"0.0.0.2 255.255.255.255 0.0.0.2\n" +
			"0.0.0.3 255.255.255.255 0.0.0.0\n", "YES"));
		tests.add(new Test("4\n" +
			"192.168.0.0 255.255.255.0 192.168.14.1\n" +
			"192.168.1.0 255.255.255.0 192.168.14.1\n" +
			"192.168.2.0 255.255.255.0 192.168.14.2\n" +
			"192.168.3.0 255.255.255.0 192.168.14.2\n" +
			"2\n" +
			"192.168.0.0 255.255.252.0 192.168.14.1\n" +
			"192.168.2.0 255.255.254.0 192.168.14.2", "YES"));
		tests.add(new Test("1\n" +
			"192.168.0.0 255.255.255.0 192.168.14.1\n" +
			"2\n" +
			"192.168.0.0 255.255.255.0 192.168.14.1\n" +
			"172.16.0.0 255.255.0.0 172.16.0.1", "NO"));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
		return tests;
	}

	private void run() {
		//noinspection InfiniteLoopStatement
//		while (true)
//		int testCount = in.readInt();
//		for (int i = 0; i < testCount; i++)
		solve();
		exit();
	}

	private TaskJ() {
		@SuppressWarnings({"UnusedDeclaration"})
		String id = getClass().getName().toLowerCase();
		//noinspection EmptyTryBlock
		try {
//			System.setIn(new FileInputStream(id + ".in"));
//			System.setOut(new PrintStream(new FileOutputStream(id + ".out")));
//			System.setIn(new FileInputStream("input.txt"));
//			System.setOut(new PrintStream(new FileOutputStream("output.txt")));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		in = new StreamInputReader(System.in);
		out = new PrintWriter(System.out);
		testMode = false;
	}

	@SuppressWarnings({"UnusedParameters"})
	private static String check(String input, String result, String output) {
//		return strictCheck(result, output);
		return tokenCheck(result, output);
	}

	public static void main(String[] args) {
		if (args.length != 0 && args[0].equals("42"))
			test();
		else
			new TaskJ().run();
	}

	private static void test() {
		List<Test> tests = createTests();
		int testCase = 0;
		for (Test test : tests) {
			System.out.print("Test #" + testCase + ": ");
			InputReader in = new StringInputReader(test.getInput());
			StringWriter out = new StringWriter(test.getOutput().length());
			long time = System.currentTimeMillis();
			try {
				new TaskJ(in, new PrintWriter(out)).run();
			} catch (TestException e) {
				time = System.currentTimeMillis() - time;
				String checkResult = check(test.getInput(), out.getBuffer().toString(), test.getOutput());
				if (checkResult == null)
					System.out.print("OK");
				else
					System.out.print("WA (" + checkResult + ")");
				System.out.printf(" in %.3f s.\n", time / 1000.);
			} catch (Throwable e) {
				System.out.println("Exception thrown:");
				e.printStackTrace(System.out);
			}
			testCase++;
		}
	}

	private static String tokenCheck(String result, String output) {
		StringInputReader resultStream = new StringInputReader(result);
		StringInputReader outputStream = new StringInputReader(output);
		int index = 0;
		boolean readingResult = false;
		try {
			while (true) {
				readingResult = true;
				String resultToken = resultStream.readString();
				readingResult = false;
				String outputToken = outputStream.readString();
				if (!resultToken.equals(outputToken))
					return "'" + outputToken + "' expected at " + index + " but '" + resultToken + "' received";
				index++;
			}
		} catch (InputMismatchException e) {
			if (readingResult) {
				try {
					outputStream.readString();
					return "only " + index + " tokens received";
				} catch (InputMismatchException e1) {
					return null;
				}
			} else
				return "only " + index + " tokens expected";
		}
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static String strictCheck(String result, String output) {
		if (result.equals(output))
			return null;
		return "'" + output + "' expected but '" + result + "' received";
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static boolean isDoubleEquals(double expected, double result, double certainty) {
		return Math.abs(expected - result) < certainty || Math.abs(expected - result) < certainty * expected;
	}

	private TaskJ(InputReader in, PrintWriter out) {
		this.in = in;
		this.out = out;
		testMode = true;
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private void exit() {
		out.close();
		if (testMode)
			throw new TestException();
		System.exit(0);
	}

	private static class Test {
		private final String input;
		private final String output;

		private Test(String input, String output) {
			this.input = input;
			this.output = output;
		}

		public String getInput() {
			return input;
		}

		public String getOutput() {
			return output;
		}
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private abstract static class InputReader {
		public abstract int read();

		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private String readLine0() {
			StringBuffer buf = new StringBuffer();
			int c = read();
			while (c != '\n' && c != -1) {
				if (c != '\r')
					buf.appendCodePoint(c);
				c = read();
			}
			return buf.toString();
		}

		public String readLine() {
			String s = readLine0();
			while (s.trim().length() == 0)
				s = readLine0();
			return s;
		}

		public String readLine(boolean ignoreEmptyLines) {
			if (ignoreEmptyLines)
				return readLine();
			else
				return readLine0();
		}

		public BigInteger readBigInteger() {
			try {
				return new BigInteger(readString());
			} catch (NumberFormatException e) {
				throw new InputMismatchException();
			}
		}

		public char readCharacter() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			return (char) c;
		}

		public double readDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, readInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, readInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public int[] readIntArray(int size) {
			int[] array = new int[size];
			for (int i = 0; i < size; i++)
				array[i] = readInt();
			return array;
		}

		public long[] readLongArray(int size) {
			long[] array = new long[size];
			for (int i = 0; i < size; i++)
				array[i] = readLong();
			return array;
		}

		public double[] readDoubleArray(int size) {
			double[] array = new double[size];
			for (int i = 0; i < size; i++)
				array[i] = readDouble();
			return array;
		}

		public String[] readStringArray(int size) {
			String[] array = new String[size];
			for (int i = 0; i < size; i++)
				array[i] = readString();
			return array;
		}

		public char[][] readTable(int rowCount, int columnCount) {
			char[][] table = new char[rowCount][columnCount];
			for (int i = 0; i < rowCount; i++) {
				for (int j = 0; j < columnCount; j++)
					table[i][j] = readCharacter();
			}
			return table;
		}

		public void readIntArrays(int[]... arrays) {
			for (int i = 0; i < arrays[0].length; i++) {
				for (int j = 0; j < arrays.length; j++)
					arrays[j][i] = readInt();
			}
		}
	}

	private static class StreamInputReader extends InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public StreamInputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
	}

	private static class StringInputReader extends InputReader {
		private Reader stream;
		private char[] buf = new char[1024];
		private int curChar, numChars;

		public StringInputReader(String stream) {
			this.stream = new StringReader(stream);
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
	}

	private static class TestException extends RuntimeException {}
}
